#include <iostream>
using namespace std;


#include "inherit.h"


// class A{
//     public:
//     A()//C++的构造函数不可被设置虚拟函数，构造函数只调用一次，且实例化自动调用，也就不存在构造函数需求
//     //其次，
//     {
//         cout<<"A()"<<endl;
//     }
//     void print()
//     {
//         cout<<"A::print()"<<endl;
//     }
//     virtual ~A()//析构函数可以设置为虚函数，便于父类指针指向子类对象时，析构可以完成子类的清理（子类析构函数调用完成会自动调一次本身的父类构造函数）
//     {

//     }
// };

// class B : public A
// {
//     public:
//     B()
//     {
//         cout<<"B()"<<endl;
//     }
//     void print()
//     {
//         cout<<"B::print()"<<endl;
//     }
//     ~B()
//     {
//         cout<<"~B()"<<endl;
//     }
// };

// int main()
// {
//     B b;
//     return 0;
// }



// class A{
//     public:
//     virtual void  func1(int a = 10)
//     {
//         cout<<"A::func1()  "<<a<<endl;
//     }
// };
// class B {
//     public:
//     virtual  void func1(int a = 20)
//     {
//         cout<<"B::func1()  "<<a<<endl;
//     }
// };
// class C : public A, public B {
//     public:
//     void func1(int a = 30)
//     {
//         cout<<"C::func1()  "<<a<<endl;
//     }
// };
// int main()
// {
//     A* pa = new C();
//     B* pb = new C();
//     pa->func1();
//     pb->func1();
	
// 	A* APA = new A();
// 	B* BPB = new B();
// 	APA->func1();
// 	BPB->func1();
//     return 0;
//     return 0;
// }



// //纯虚函数
// class Base{
//     public:
//     virtual void print()=0;
//     void test(int a)
//     {
//         cout<<"base:: "<<a<<endl;
//     }
// };

// class Derived_withoutinplement : public Base{
//     public:
// };

// class Derived_withinplement : public Base{
//     public:
//     void print(){
//         cout<<"print()"<<endl;
//     }
//     void test()
//     {
//         cout<<"D::test()"<<endl;
//     }
// };

// int main()
// {
//     Derived_withinplement d2;
//     // d2.test(2) ;
//     return 0;
// }


// class A{

//     public:
//     int func()
//     {
//         this->function();
//         return 0;
//     }
//     public:
//     static int function();
// };
// int A::function()
// {
//     cout<<"A::function()"<<endl;
//     return 0;
// }


// class B :public A{
//     public:
//     int func()
//     {
//         this->function();
//         return 0;
//     }
// };

// typedef int(*funptr)();
// typedef int (A::*Afunc)();
// int main()
// {
//     A a;
//     funptr Afuntion = A::function;
//     Afunc afunc = A::func;
//     cout<<"Afuntion address::"<<(void*)Afuntion<<endl;
//     cout<<"afunc address::"<<A::func<<endl;//这里不能进行强转，打印结果也是1，经过测试，C++成员函数取地址结果都是一，说明静态成员函数是很特殊的
//     return 0;
// }


class MyClass {
public:
    void myFunction() {
        std::cout << "Hello from myFunction!" << std::endl;
    }
};

int main() {
    MyClass obj;
    void (MyClass::*myFunctionPointer)() = &MyClass::myFunction;
    std::cout << "Address of myFunction: " << myFunctionPointer << std::endl;
    return 0;
}